Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@bracket-pathfinding/examples/floyd_warshall/common.rs`:
- Around line 105-110: The code duplicates the south-west diagonal check by
calling valid_exit(location, Point::new(-1, 1)) twice, which omits the
south-east diagonal; update the second occurrence to call valid_exit(location,
Point::new(1, 1)) so the exits vector gets the southeast neighbor (push the same
weight 1.4), i.e., change the duplicate Point::new(-1, 1) to Point::new(1, 1) in
the block that builds exits using valid_exit and pushes into exits.

In `@bracket-pathfinding/examples/floyd_warshall/main.rs`:
- Line 23: The reachability check is using the wrong flattened index: replace
the use of flow_map.depth_map[idx] with flow_map.depth_map[depth_map_idx] so the
test checks the start_idx → idx entry (the same entry the gradient rendering
uses); update the if condition that currently reads `if flow_map.depth_map[idx]
< f32::MAX` to use `depth_map_idx` (and ensure depth_map_idx is computed as
`start_idx * mapsize + idx` or the existing calculation) so reachability and
rendered depth are consistent.

In `@bracket-pathfinding/README.md`:
- Line 108: The README heading "Floyd-Washall Mapping" contains a typo; update
the heading text to "Floyd-Warshall Mapping" by replacing the string
"Floyd-Washall" with "Floyd-Warshall" in the README (the section title line that
currently reads "## Floyd-Washall Mapping").
- Line 141: The README line describing the example `floyd_warshall` is
incorrect: it says it demonstrates "Dijkstra mapping" but the example implements
the Floyd–Warshall algorithm (all-pairs shortest paths). Update the bullet for
`floyd_warshall` to accurately describe what the example shows (e.g.,
"Floyd–Warshall (cargo run --example floyd_warshall), demonstrating the
Floyd–Warshall all-pairs shortest-path algorithm" or similar), replacing the
Dijkstra wording; reference the `floyd_warshall` example name in your edit.

In `@bracket-pathfinding/src/floyd_warshall.rs`:
- Around line 21-22: The current conversion uses size_x.try_into().ok().unwrap()
and size_y.try_into().ok().unwrap(), which hides conversion errors and produces
an opaque panic; replace these with explicit error handling such as
size_x.try_into().expect("failed to convert size_x to usize") and
size_y.try_into().expect("failed to convert size_y to usize") or propagate the
Result from the function so failures carry context—update the bindings sz_x and
sz_y accordingly to use expect (or ? propagation) instead of .ok().unwrap().

---

Nitpick comments:
In `@bracket-pathfinding/src/floyd_warshall.rs`:
- Around line 41-126: Change the free functions build, find_lowest_exit, and
find_highest_exit into inherent methods on FloydWarshallMap using &mut self for
build and &self for the two finders (so callers can use fm.build(map),
fm.find_lowest_exit(pos, map), fm.find_highest_exit(pos, map)); update
signatures and bodies to remove the explicit fm parameter and reference fields
directly (e.g., self.size_x, self.size_y, self.idx_helper(...), self.depth_map,
self.max_depth) and adjust the new method receiver in any callers and in new()
if it currently calls build as a free function. Ensure mutability for build so
it writes to self.depth_map and keep find_lowest_exit/find_highest_exit as
non-mutating &self methods.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@bracket-pathfinding/src/floyd_warshall.rs`:
- Around line 17-31: Add colocated unit tests for FloydWarshallMap::new in a
tests.rs inside the same module: test that constructing with small sizes (use
TryInto-able integers) produces FloydWarshallMap with size_x and size_y set
correctly and map.len() == size_x * size_y, that every entry in the map vector
equals f32::MAX initially, and a simple sanity test using a minimal BaseMap stub
where reachable adjacency is known to assert default max_depth is stored in
max_depth and no paths are computed by new (i.e., map entries remain f32::MAX).
Reference FloydWarshallMap::new and the struct fields map, size_x, size_y, and
max_depth when writing the assertions.
- Around line 23-31: The constructor is allocating sz_x * sz_y (one distance per
tile) and skips computation; change allocation to tile_count * tile_count using
checked multiplication (e.g., let tile_count =
sz_x.checked_mul(sz_y).expect("..."); let total =
tile_count.checked_mul(tile_count).expect("...")) to avoid overflow, initialize
map Vec<f32> with total entries, then call FloydWarshallMap::build(&mut f,
starts, map) (uncomment/restore that call) before returning the FloydWarshallMap
so the all-pairs distances are computed; keep references to FloydWarshallMap,
build, sz_x, sz_y, starts, map, and max_depth to locate the edits.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@bracket-pathfinding/src/floyd_warshall.rs`:
- Around line 74-96: The helpers currently pick exits by local edge cost; update
both find_lowest_exit and find_highest_exit to accept an additional
target/source index parameter (e.g., dest: usize) and use fm.idx_helper(exit,
dest) to look up the distance in fm.depth_map when ranking candidates instead of
fm.idx_helper(position, exit). Specifically, change signatures of
find_lowest_exit and find_highest_exit to include the destination/source,
iterate exits from map.get_available_exits(position), compute pos =
fm.idx_helper(exit, dest) and compare fm.depth_map[pos] to choose the min/max
exit, and add a regression test with asymmetric edge weights exercising both
helpers so the choice depends on distance-to-target rather than the immediate
edge cost.
- Around line 41-69: The build function must reset fm.depth_map before
recomputing paths to avoid stale values; in FloydWarshallMap::build, initialize
fm.depth_map to the default "infinite" distance for all pairs (e.g., fill with
f32::INFINITY or a large sentinel) sized to mapsize*mapsize (or call a
reset/clear helper on fm.depth_map), then set the diagonal entries to 0 (using
idx_helper(start_idx, start_idx)) and populate direct exits from
map.get_available_exits as you already do, before running the triple-loop that
updates entries; this ensures removed edges or changed weights don't leave old
shorter distances in depth_map.